home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / mui / mcc_settingswindow / sources / structsupport.h < prev   
C/C++ Source or Header  |  1999-02-08  |  16KB  |  1,019 lines
  1.  
  2. /* Structure Support Functions */
  3.  
  4.  
  5. static void Type_Next(UWORD *&des)
  6. {
  7.     switch(*des)
  8.         {
  9.         case SWIS_ARRAY:
  10.             des=&des[2];
  11.             Type_Next(des);
  12.             break;
  13.  
  14.         case SWIS_STRING:
  15.             des=&des[2];
  16.             break;
  17.  
  18.         case SWIS_POINTER:
  19.             des=&des[1];
  20.             Type_Next(des);
  21.             break;
  22.  
  23.         case SWIS_STRUCT:
  24.             des=&des[1];
  25.  
  26.             while (*des!=(UWORD)SWIS_END)
  27.                 {
  28.                 Type_Next(des);
  29.                 }
  30.  
  31.             des=&des[1];
  32.             break;
  33.  
  34.         case SWIS_BYTE:
  35.         case SWIS_WORD:
  36.         case SWIS_LONG:
  37.         case SWIS_EVEN:
  38.         case SWIS_EVEN4:
  39.         default:
  40.             des=&des[1];
  41.             break;
  42.         }
  43. }
  44.  
  45.  
  46. static ULONG Type_Check(ULONG &data, UWORD *&des)
  47. {
  48.     ULONG len=0;
  49.  
  50.     switch(*des)
  51.         {
  52.         case SWIS_BYTE:
  53.             len=1;
  54.             data+=1;
  55.             des=&des[1];
  56.             break;
  57.  
  58.         case SWIS_WORD:
  59.             len=2;
  60.             data+=2;
  61.             des=&des[1];
  62.             break;
  63.  
  64.         case SWIS_LONG:
  65.             len=4;
  66.             data+=4;
  67.             des=&des[1];
  68.             break;
  69.  
  70.         case SWIS_ARRAY:
  71.             {
  72.             ULONG    i,anz;
  73.             UWORD *des2;
  74.  
  75.             anz=des[1];            /* muß immer >0 sein!!! */
  76.             des=des2=&des[2];
  77.  
  78.             for (i=0;i<anz;i++)
  79.                 {
  80.                 des2=des;
  81.                 len+=Type_Check(data,des2);
  82.                 }
  83.  
  84.             des=des2;
  85.             break;
  86.             }
  87.  
  88.         case SWIS_STRING:
  89.             {
  90.             if (des[1]==(UWORD)-1)
  91.                 {
  92.                 len=strlen((STRPTR)data)+1;
  93.                 }
  94.             else
  95.                 {
  96.                 len=des[1];
  97.                 }
  98.  
  99.             data+=len;
  100.             des=&des[2];
  101.             break;
  102.             }
  103.  
  104.         case SWIS_POINTER:
  105.             des=&des[1];
  106.             Type_Next(des);
  107.             len=4;
  108.             data+=4;
  109.             break;
  110.  
  111.         case SWIS_STRUCT:
  112.             des=&des[1];
  113.  
  114.             while (*des!=(UWORD)SWIS_END)
  115.                 {
  116.                 len+=Type_Check(data,des);
  117.                 }
  118.  
  119.             des=&des[1];
  120.             break;
  121.  
  122.         case SWIS_EVEN:
  123.             if (data & 1)
  124.                 {
  125.                 len+=1;
  126.                 data+=1;
  127.                 }
  128.  
  129.             des=&des[1];
  130.             break;
  131.  
  132.         case SWIS_EVEN4:
  133.             {
  134.             ULONG uneven;
  135.  
  136.             if (uneven=data & 3)
  137.                 {
  138.                 len+=uneven;
  139.                 data+=uneven;
  140.                 }
  141.  
  142.             des=&des[1];
  143.             break;
  144.             }
  145.  
  146.         default:
  147.             len=*des;
  148.             des=&des[1];
  149.             break;
  150.         }
  151.  
  152.     return(len);
  153. }
  154.  
  155.  
  156. static ULONG Type_Size(ULONG &data, UWORD *&des)
  157. {
  158.     ULONG len=0;
  159.  
  160. D2(BUG("%ld: ",*des));
  161.  
  162.     switch(*des)
  163.         {
  164.         case SWIS_BYTE:
  165. D2(BUG("BYTE: %ld\n",*(UBYTE *)data));
  166.             len=1;
  167.             data+=1;
  168.             des=&des[1];
  169.             break;
  170.  
  171.         case SWIS_WORD:
  172. D2(BUG("WORD: %ld\n",*(UWORD *)data));
  173.             len=2;
  174.             data+=2;
  175.             des=&des[1];
  176.             break;
  177.  
  178.         case SWIS_LONG:
  179. D2(BUG("LONG: %ld\n",*(ULONG *)data));
  180.             len=4;
  181.             data+=4;
  182.             des=&des[1];
  183.             break;
  184.  
  185.         case SWIS_ARRAY:
  186.             {
  187.             ULONG    i,anz;
  188.             UWORD *des2;
  189.  
  190. D2(BUG("ARRAY\n"));
  191.  
  192.             anz=des[1];            /* muß immer >0 sein!!! */
  193.             des=des2=&des[2];
  194.  
  195.             for (i=0;i<anz;i++)
  196.                 {
  197.                 des2=des;
  198.                 len+=Type_Size(data,des2);
  199.                 }
  200.  
  201.             des=des2;
  202.             break;
  203.             }
  204.  
  205.         case SWIS_STRING:
  206.             {
  207. D2(BUG("STRING: %s\n",data));
  208.             if (des[1]==(UWORD)-1)
  209.                 {
  210.                 len=strlen((STRPTR)data)+1;
  211.                 }
  212.             else
  213.                 {
  214.                 len=des[1];
  215.                 }
  216.  
  217.             data+=len;
  218.             des=&des[2];
  219.             break;
  220.             }
  221.  
  222.         case SWIS_POINTER:
  223.             {
  224. D2(BUG("POINTER: %p\n",*(ULONG *)data));
  225.  
  226.             if (*(ULONG *)data)
  227.                 {
  228.                 ULONG data2=*(ULONG *)data;
  229.  
  230.                 des=&des[1];
  231.                 len=4+((Type_Size(data2,des)+3) & ~3);
  232.                 data+=4;
  233.                 }
  234.             else
  235.                 {
  236.                 /* Pointer ist NULL, nur des weiterstellen und data+4 */
  237.  
  238.                 Type_Next(des);
  239.                 data+=4;
  240.                 }
  241.  
  242.             break;
  243.             }
  244.  
  245.         case SWIS_STRUCT:
  246. D2(BUG("STRUCT\n"));
  247.             des=&des[1];
  248.  
  249.             while (*des!=(UWORD)SWIS_END)
  250.                 {
  251.                 len+=Type_Size(data,des);
  252.                 }
  253.  
  254.             des=&des[1];
  255.             break;
  256.  
  257.         case SWIS_EVEN:
  258. D2(BUG("EVEN\n"));
  259.             if (data & 1)
  260.                 {
  261.                 len+=1;
  262.                 data+=1;
  263.                 }
  264.  
  265.             des=&des[1];
  266.             break;
  267.  
  268.         case SWIS_EVEN4:
  269.             {
  270.             ULONG uneven;
  271.  
  272. D2(BUG("EVEN4\n"));
  273.  
  274.             if (uneven=data & 3)
  275.                 {
  276.                 len+=uneven;
  277.                 data+=uneven;
  278.                 }
  279.  
  280.             des=&des[1];
  281.             break;
  282.             }
  283.  
  284.         default:
  285.             len=*des;
  286.             des=&des[1];
  287.             break;
  288.         }
  289.  
  290.     return(len);
  291. }
  292.  
  293.  
  294. static void Type_Copy(ULONG &source, ULONG &dest, ULONG &nextdest,
  295.     UWORD *&des)
  296. {
  297.     switch(*des)
  298.         {
  299.         case SWIS_BYTE:
  300. D2(BUG("Copy BYTE: %ld\n",*(UBYTE *)source));
  301.             *(UBYTE *)dest=*(UBYTE *)source;
  302.             source+=1;
  303.             dest+=1;
  304.             des=&des[1];
  305.             break;
  306.  
  307.         case SWIS_WORD:
  308. D2(BUG("Copy WORD: %ld\n",*(UWORD *)source));
  309.             *(UWORD *)dest=*(UWORD *)source;
  310.             source+=2;
  311.             dest+=2;
  312.             des=&des[1];
  313.             break;
  314.  
  315.         case SWIS_LONG:
  316. D2(BUG("Copy LONG: %ld\n",*(ULONG *)source));
  317.             *(ULONG *)dest=*(ULONG *)source;
  318.             source+=4;
  319.             dest+=4;
  320.             des=&des[1];
  321.             break;
  322.  
  323.         case SWIS_ARRAY:
  324.             {
  325.             ULONG    i,anz;
  326.             UWORD *des2;
  327.  
  328. D2(BUG("Copy ARRAY\n"));
  329.  
  330.             anz=des[1];            /* muß immer >0 sein!!! */
  331.             des=des2=&des[2];
  332.  
  333.             for (i=0;i<anz;i++)
  334.                 {
  335.                 des2=des;
  336.                 Type_Copy(source,dest,nextdest,des2);
  337.                 }
  338.  
  339.             des=des2;
  340.  
  341. D2(BUG("Copy ARRAY End\n"));
  342.  
  343.             break;
  344.             }
  345.  
  346.         case SWIS_STRING:
  347.             {
  348.             ULONG len;
  349.  
  350. D2(BUG("Copy STRING: %s\n",source));
  351.  
  352.             if (des[1]==(UWORD)-1)
  353.                 {
  354.                 len=strlen((STRPTR)source)+1;
  355.                 }
  356.             else
  357.                 {
  358.                 len=des[1];
  359.                 }
  360.  
  361.             memcpy((STRPTR)dest,(STRPTR)source,len);
  362.  
  363.             source+=len;
  364.             dest+=len;
  365.             des=&des[2];
  366.             break;
  367.             }
  368.  
  369.         case SWIS_POINTER:
  370.             {
  371. D2(BUG("Copy POINTER\n"));
  372.  
  373.             if (*(ULONG *)source)
  374.                 {
  375.                 ULONG source2=*(ULONG *)source;
  376.                 ULONG source3=source2;
  377.                 ULONG dest2=nextdest;
  378.                 UWORD *des2=des=&des[1];
  379.  
  380.                 *(ULONG *)dest=dest2;
  381.  
  382.                 /* neues nextdest berechnen und rekursieren */
  383.  
  384.                 nextdest=(nextdest+Type_Check(source3,des2)+3) & ~3;
  385.                 Type_Copy(source2,dest2,nextdest,des);
  386.  
  387.                 source+=4;
  388.                 dest+=4;
  389.                 }
  390.             else
  391.                 {
  392.                 /* Pointer ist NULL, nur des weiterstellen und data+4 */
  393.  
  394.                 *(ULONG *)dest=NULL;
  395.                 Type_Next(des);
  396.                 source+=4;
  397.                 dest+=4;
  398.                 }
  399.  
  400.             break;
  401.             }
  402.  
  403.         case SWIS_STRUCT:
  404.  
  405. D2(BUG("Copy STRUCT\n"));
  406.  
  407.             des=&des[1];
  408.  
  409.             while (*des!=(UWORD)SWIS_END)
  410.                 {
  411.                 Type_Copy(source,dest,nextdest,des);
  412.                 }
  413.  
  414.             des=&des[1];
  415.  
  416. D2(BUG("Copy STRUCT End\n"));
  417.  
  418.             break;
  419.  
  420.         case SWIS_EVEN:
  421. D2(BUG("Copy EVEN\n"));
  422.  
  423.             source=(source+1) & ~1;
  424.             dest=(dest+1) & ~1;
  425.             des=&des[1];
  426.             break;
  427.  
  428.         case SWIS_EVEN4:
  429. D2(BUG("Copy EVEN4\n"));
  430.  
  431.             source=(source+3) & ~3;
  432.             dest=(dest+3) & ~3;
  433.             des=&des[1];
  434.             break;
  435.  
  436.         default:
  437. D2(BUG("Copy DEFAULT\n"));
  438.             memcpy((APTR)dest,(APTR)source,*des);
  439.             source+=*des;
  440.             dest+=*des;
  441.             des=&des[1];
  442.             break;
  443.         }
  444. }
  445.  
  446.  
  447. static void Type_Reloc(ULONG &data, UWORD *&des, ULONG reloc)
  448. {
  449.     switch(*des)
  450.         {
  451.         case SWIS_BYTE:
  452.             data+=1;
  453.             des=&des[1];
  454.             break;
  455.  
  456.         case SWIS_WORD:
  457.             data+=2;
  458.             des=&des[1];
  459.             break;
  460.  
  461.         case SWIS_LONG:
  462.             data+=4;
  463.             des=&des[1];
  464.             break;
  465.  
  466.         case SWIS_ARRAY:
  467.             {
  468.             ULONG    i,anz;
  469.             UWORD *des2;
  470.  
  471.             anz=des[1];            /* muß immer >0 sein!!! */
  472.             des=des2=&des[2];
  473.  
  474.             for (i=0;i<anz;i++)
  475.                 {
  476.                 des2=des;
  477.                 Type_Reloc(data,des2,reloc);
  478.                 }
  479.  
  480.             des=des2;
  481.             break;
  482.             }
  483.  
  484.         case SWIS_STRING:
  485.             {
  486.             if (des[1]==(UWORD)-1)
  487.                 {
  488.                 data+=strlen((STRPTR)data)+1;
  489.                 }
  490.             else
  491.                 {
  492.                 data+=des[1];
  493.                 }
  494.  
  495.             des=&des[2];
  496.             break;
  497.             }
  498.  
  499.         case SWIS_POINTER:
  500.             {
  501.             if (*(ULONG *)data)
  502.                 {
  503.                 ULONG data2;
  504.  
  505.                 *(ULONG *)data+=reloc;
  506.                 data2=*(ULONG *)data;
  507.  
  508.                 des=&des[1];
  509.                 Type_Reloc(data2,des,reloc);
  510.                 data+=4;
  511.                 }
  512.             else
  513.                 {
  514.                 /* Pointer ist NULL, nur des weiterstellen und data+4 */
  515.  
  516.                 Type_Next(des);
  517.                 data+=4;
  518.                 }
  519.  
  520.             break;
  521.             }
  522.  
  523.         case SWIS_STRUCT:
  524.             des=&des[1];
  525.  
  526.             while (*des!=(UWORD)SWIS_END)
  527.                 {
  528.                 Type_Reloc(data,des,reloc);
  529.                 }
  530.  
  531.             des=&des[1];
  532.             break;
  533.  
  534.         case SWIS_EVEN:
  535.             if (data & 1)
  536.                 {
  537.                 data+=1;
  538.                 }
  539.  
  540.             des=&des[1];
  541.             break;
  542.  
  543.         case SWIS_EVEN4:
  544.             {
  545.             ULONG uneven;
  546.  
  547.             if (uneven=data & 3)
  548.                 {
  549.                 data+=uneven;
  550.                 }
  551.  
  552.             des=&des[1];
  553.             break;
  554.             }
  555.  
  556.         default:
  557.             des=&des[1];
  558.             break;
  559.         }
  560. }
  561.  
  562.  
  563.  
  564. /* Entry Support Functions */
  565.  
  566.  
  567. ULONG Entry_Size(ULONG source, UWORD *des)
  568. {
  569.     return((source) ? (Type_Size(source,des)+3) & ~3 : 0);
  570. }
  571.  
  572. ULONG Entry_SmartCopy(ULONG source, ULONG dest, UWORD *des)
  573. {
  574.     ULONG source1=source;    /* Trashvariable für source */
  575.     UWORD *des1=des;            /* Trashvariable für des */
  576.     ULONG nextdest;
  577.  
  578.     /* Adresse des nächsten freien Segments berechnen */
  579.  
  580.     source1=source;
  581.     des1=des;
  582.     nextdest=(dest+Type_Check(source1,des1)+3) & ~3;
  583.  
  584.     /* Kopieren der gesamten Struktur */
  585.  
  586.     Type_Copy(source,dest,nextdest,des);
  587.  
  588.     return(nextdest);
  589. }
  590.  
  591.  
  592. void Entry_Reloc(ULONG source, UWORD *des, ULONG reloc)
  593. {
  594.     Type_Reloc(source,des,reloc);
  595. }
  596.  
  597.  
  598.  
  599. /* Complex Support Functions */
  600.  
  601.  
  602. struct MUIS_SettingsWindow_ComplexContents *Complex_SmartStore(Object *obj,
  603.     ULONG attr, UWORD *des, void *pool)
  604. {
  605.     struct MUIS_SettingsWindow_ComplexContents *entry=NULL;
  606.     ULONG data,size;
  607.  
  608. D(BUG("Complex_SmartStore\n"));
  609.  
  610.     if (obj)
  611.         {
  612.         /* Get a pointer to the entry */
  613.  
  614.         get(obj,attr,&data);
  615.  
  616.         /* Bestimmen der Größe des Entries */
  617.  
  618.         size=Entry_Size(data,des);
  619.  
  620.         /* Speicher besorgen */
  621.  
  622.         if (entry=AllocVecPooled(pool,
  623.                 sizeof(struct MUIS_SettingsWindow_ComplexContents)+size))
  624.             {
  625.             entry->swc_Size=sizeof(struct MUIS_SettingsWindow_ComplexContents)
  626.                 +size;
  627.  
  628.             /* Relocposition */
  629.  
  630.             entry->swc_Reloc=(ULONG)entry;
  631.  
  632.             /* Kopieren */
  633.  
  634.             if (data)
  635.                 {
  636.                 Entry_SmartCopy(data,(ULONG)&entry->swc_Entry,des);
  637.                 }
  638.             }
  639.         }
  640.  
  641. D(BUG("Complex_SmartStore End\n"));
  642.  
  643.     return(entry);
  644. }
  645.  
  646.  
  647. void Complex_Store(struct MUIS_SettingsWindow_Item *item, void *pool)
  648. {
  649.     struct MUIS_SettingsWindow_ComplexContents *entry=NULL;
  650.  
  651. D(BUG("Complex_Store\n"));
  652.  
  653.     if (item->swi_Obj)
  654.         {
  655.         /* free old entries */
  656.  
  657.         if (item->swi_Contents)
  658.             {
  659.             FreeVecPooled(pool,(APTR)item->swi_Contents);
  660.             }
  661.  
  662.         entry=Complex_SmartStore(item->swi_Obj,item->swi_Attr,
  663.             (UWORD *)item->swi_Size,pool);
  664.         }
  665.  
  666.     item->swi_Contents=(ULONG)entry;
  667.  
  668. D(BUG("Complex_Store End\n"));
  669. }
  670.  
  671.  
  672. void Complex_Reloc(MUIS_SettingsWindow_ComplexContents *item, UWORD *des)
  673. {
  674.     ULONG reloc;
  675.  
  676. D(BUG("Complex_Reloc\n"));
  677.  
  678.     if (item)
  679.         {
  680.         /* Relocation berechnen und neu setzen */
  681.  
  682.         reloc=(ULONG)item-item->swc_Reloc;
  683.         item->swc_Reloc=(ULONG)item;
  684.  
  685.         /* Entry relozieren */
  686.  
  687.         Entry_Reloc((ULONG)&item->swc_Entry,des,reloc);
  688.         }
  689.  
  690. D(BUG("Complex_Reloc End\n"));
  691. }
  692.  
  693.  
  694. struct MUIS_SettingsWindow_ComplexContents *Complex_Duplicate(
  695.     struct MUIS_SettingsWindow_ComplexContents *source,
  696.     UWORD *des, void *pool)
  697. {
  698.     struct MUIS_SettingsWindow_ComplexContents *dest=NULL;
  699.  
  700. D(BUG("Complex_Duplicate\n"));
  701.  
  702.     if (dest=AllocVecPooled(pool,source->swc_Size))
  703.         {
  704.         CopyMem(source,dest,source->swc_Size);
  705.  
  706.         Complex_Reloc(dest,des);
  707.         }
  708.  
  709. D(BUG("Complex_Duplicate End!\n"));
  710.  
  711.     return(dest);
  712. }
  713.  
  714.  
  715.  
  716. /* List Support Functions */
  717.  
  718.  
  719. struct MUIS_SettingsWindow_ListContents *List_SmartStore(Object *list,
  720.     ULONG type, UWORD *des, void *pool)
  721. {
  722.     ULONG entryanz;
  723.     struct MUIS_SettingsWindow_ListContents *entrytable=NULL;
  724.     ULONG *temptable=NULL;
  725.     ULONG i,size=0;
  726.     ULONG dest;
  727.  
  728. D(BUG("List_SmartStore\n"));
  729.  
  730.     if (list)
  731.         {
  732.         /* Get the number of entries */
  733.  
  734.         get(list,
  735.             type & SWIT_NLIST?MUIA_NList_Entries:MUIA_List_Entries,
  736.             &entryanz);
  737.  
  738.         /* Alloc mem for temporary table */
  739.  
  740.         temptable=AllocVecPooled(pool, entryanz*sizeof(ULONG));
  741.  
  742.         if ((temptable) || entryanz==0)
  743.             {
  744.             /* Bestimmen der Gesamtlänge */
  745.  
  746.             for (i=0;i<entryanz;i++)
  747.                 {
  748.                 /* Get list entry */
  749.  
  750.                 DoMethod(list,
  751.                     type & SWIT_NLIST?MUIM_NList_GetEntry:MUIM_List_GetEntry,
  752.                     i,
  753.                     &temptable[i]);
  754.  
  755.                 /* Bestimmen der Größe des Listentries */
  756.  
  757.                 if (temptable[i])
  758.                     {
  759.                     switch (type & SWIT_TYPES)
  760.                         {
  761.                         case SWIT_LISTSTANDARD:
  762.                             break;
  763.  
  764.                         case SWIT_LISTSTRING:
  765.                             if ((ULONG)des!=-1)
  766.                                 {
  767.                                 size+=(ULONG)des;
  768.                                 }
  769.                             else
  770.                                 {
  771.                                 size+=strlen((STRPTR)temptable[i])+1;
  772.                                 }
  773.  
  774.                             break;
  775.  
  776.                         case SWIT_LISTSTRUCT:
  777.                             size+=((ULONG)des + 3) & ~3;
  778.                             break;
  779.  
  780.                         case SWIT_LISTCOMPLEX:
  781.                         case SWIT_LISTCUSTOM:
  782.                             size+=Entry_Size(temptable[i],des);
  783.                             break;
  784.                         }
  785.                     }
  786.                 }
  787.  
  788.             /* Speicher für alles besorgen, Entries kopieren */
  789.  
  790.             if (entrytable=AllocVecPooled(pool, sizeof(struct MUIS_SettingsWindow_ListContents)
  791.                     +(entryanz+1)*sizeof(ULONG)+size))
  792.                 {
  793.                 entrytable->swl_Size=sizeof(struct MUIS_SettingsWindow_ListContents)
  794.                     +(entryanz+1)*sizeof(ULONG)+size;
  795.  
  796.                 /* Anzahl der Entries */
  797.  
  798.                 entrytable->swl_Count=entryanz;
  799.  
  800.                 /* Relocposition */
  801.  
  802.                 entrytable->swl_Reloc=(ULONG)entrytable;
  803.  
  804.                 /* Zieladresse für Entries */
  805.  
  806.                 dest=(ULONG)entrytable+sizeof(struct MUIS_SettingsWindow_ListContents)
  807.                     +(entryanz+1)*sizeof(ULONG);
  808.  
  809. D2(BUG("Speicher allokiert: %p, 1.Eintrag: %p, Daten: %p\n",entrytable,&entrytable->swl_Entries[0],dest));
  810.  
  811.                 for (i=0;i<entryanz;i++)
  812.                     {
  813.                     /* Kopieren */
  814.  
  815.                     if (temptable[i])
  816.                         {
  817.                         /* Zieladresse für Entry */
  818.  
  819.                         entrytable->swl_Entries[i]=dest;
  820.  
  821.                         switch (type & SWIT_TYPES)
  822.                             {
  823.                             case SWIT_LISTSTANDARD:
  824.                                 entrytable->swl_Entries[i]=temptable[i];
  825.                                 break;
  826.  
  827.                             case SWIT_LISTSTRING:
  828.                                 if ((ULONG)des!=-1)
  829.                                     {
  830.                                     memcpy((APTR)dest,(APTR)temptable[i],(ULONG)des);
  831.                                     dest+=(ULONG)des;
  832.                                     }
  833.                                 else
  834.                                     {
  835.                                     strcpy((STRPTR)dest,(STRPTR)temptable[i]);
  836.                                     dest+=strlen((STRPTR)temptable[i])+1;
  837.                                     }
  838.  
  839.                                 break;
  840.  
  841.                             case SWIT_LISTSTRUCT:
  842.                                 memcpy((APTR)dest,(APTR)temptable[i],(ULONG)des);
  843.                                 dest+=((ULONG)des + 3) & ~3;
  844.                                 break;
  845.  
  846.                             case SWIT_LISTCOMPLEX:
  847.                             case SWIT_LISTCUSTOM:
  848.  
  849. D2(BUG("Kopiere Entry: %p -> %p\n",temptable[i],dest));
  850.  
  851.                                 dest=Entry_SmartCopy(temptable[i],dest,des);
  852.                                 break;
  853.  
  854.                             default:
  855.                                 entrytable->swl_Entries[i]=0;
  856.                             }
  857.                         }
  858.                     }
  859.                 }
  860.             }
  861.  
  862.         /* Zwischenspeicher freigeben */
  863.  
  864.         if (temptable)
  865.             {
  866.             FreeVecPooled(pool, temptable);
  867.             }
  868.         }
  869.  
  870. D(BUG("List_SmartStore End\n"));
  871.  
  872.     return(entrytable);
  873. }
  874.  
  875.  
  876. void List_Store(struct MUIS_SettingsWindow_Item *item, void *pool)
  877. {
  878.     struct MUIS_SettingsWindow_ListContents *entrytable=NULL;
  879.  
  880. D(BUG("List_Store\n"));
  881.  
  882.     if (item->swi_Obj)
  883.         {
  884.         /* free old entries */
  885.  
  886.         if (item->swi_Contents)
  887.             {
  888.             FreeVecPooled(pool, (APTR)item->swi_Contents);
  889.             }
  890.  
  891.         entrytable=List_SmartStore(item->swi_Obj,item->swi_Type,
  892.             (UWORD *)item->swi_Size, pool);
  893.         }
  894.  
  895.     item->swi_Contents=(ULONG)entrytable;
  896.  
  897. D(BUG("List_Store End\n"));
  898. }
  899.  
  900.  
  901.  
  902. void List_SmartReset(Object *list, ULONG type,
  903.     MUIS_SettingsWindow_ListContents *contents, UWORD *des)
  904. {
  905. D(BUG("List_SmartReset\n"));
  906.  
  907.     /* Liste leeren */
  908.  
  909.     DoMethod(list,
  910.         type & SWIT_NLIST?MUIM_NList_Clear:MUIM_List_Clear);
  911.  
  912.     if (contents)
  913.         {
  914.         /* Entries enfügen */
  915.  
  916.         if (contents->swl_Count>0)
  917.             {
  918.             switch(type & SWIT_TYPES)
  919.                 {
  920.                 case SWIT_LISTSTANDARD:
  921.                 case SWIT_LISTSTRING:
  922.                 case SWIT_LISTSTRUCT:
  923.                 case SWIT_LISTCOMPLEX:
  924.                     DoMethod(list,
  925.                         type & SWIT_NLIST?MUIM_NList_Insert:MUIM_List_Insert,
  926.                         contents->swl_Entries,
  927.                         contents->swl_Count,
  928.                         type & SWIT_NLIST?MUIV_NList_Insert_Bottom:MUIV_List_Insert_Bottom);
  929.  
  930.                     break;
  931.  
  932.                 case SWIT_LISTCUSTOM:
  933.                     DoMethod(list,
  934.                         MUIM_SettingsWindow_CustomInsert,
  935.                         contents->swl_Entries,
  936.                         contents->swl_Count,
  937.                         type & SWIT_NLIST?MUIV_NList_Insert_Bottom:MUIV_List_Insert_Bottom);
  938.  
  939.                     break;
  940.                 }
  941.             }
  942.         }
  943.  
  944. D(BUG("List_SmartReset End\n"));
  945. }
  946.  
  947.  
  948. void List_Reset(struct MUIS_SettingsWindow_Item *item)
  949. {
  950.     List_SmartReset(item->swi_Obj,item->swi_Type,(APTR)item->swi_Contents,(UWORD *)item->swi_Size);
  951. }
  952.  
  953.  
  954. void List_Reloc(MUIS_SettingsWindow_ListContents *item, ULONG type,
  955.     UWORD *des)
  956. {
  957.     ULONG i,reloc;
  958.  
  959. D(BUG("List_Reloc\n"));
  960.  
  961.     switch(type & SWIT_TYPES)
  962.         {
  963.         case SWIT_LISTSTANDARD:
  964.             break;
  965.  
  966.         case SWIT_LISTSTRING:
  967.         case SWIT_LISTSTRUCT:
  968.             des=NULL;
  969.  
  970.         case SWIT_LISTCOMPLEX:
  971.         case SWIT_LISTCUSTOM:
  972.  
  973.             if ((item) && item->swl_Count>0)
  974.                 {
  975.                 /* Relocation berechnen und neu setzen */
  976.  
  977.                 reloc=(ULONG)item-item->swl_Reloc;
  978.                 item->swl_Reloc=(ULONG)item;
  979.  
  980.                 for (i=0;i<item->swl_Count;i++)
  981.                     {
  982.                     /* Zeiger auf Entry und dann Entry selbst relozieren */
  983.  
  984.                     if (item->swl_Entries[i])
  985.                         {
  986.                         item->swl_Entries[i]+=reloc;
  987.  
  988.                         if (des)
  989.                             {
  990.                             Entry_Reloc(item->swl_Entries[i],des,reloc);
  991.                             }
  992.                         }
  993.                     }
  994.                 }
  995.  
  996.             break;
  997.         }
  998.  
  999. D(BUG("List_Reloc End\n"));
  1000. }
  1001.  
  1002.  
  1003. struct MUIS_SettingsWindow_ListContents *List_Duplicate(
  1004.     struct MUIS_SettingsWindow_ListContents *source,
  1005.     ULONG type, UWORD *des, void *pool)
  1006. {
  1007.     struct MUIS_SettingsWindow_ListContents *dest=NULL;
  1008.  
  1009.     if (dest=AllocVecPooled(pool, source->swl_Size))
  1010.         {
  1011.         CopyMem(source,dest,source->swl_Size);
  1012.         List_Reloc(dest,type,des);
  1013.         }
  1014.  
  1015.     return(dest);
  1016. }
  1017.  
  1018.  
  1019.